home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr46 / vfwdk.zip / VFWSDK.ZIP / SAMPLES / MOVPLAY / MOVPLAY2.C < prev   
C/C++ Source or Header  |  1993-01-27  |  17KB  |  534 lines
  1. /*--------------------------------------------------------------------
  2. |
  3. | MovPlay.c - Sample Win app to play AVI movies using mciSendString
  4. |
  5. | Movie Functions supported:
  6. |    Play/Pause
  7. |    Home/End
  8. |    Step/ReverseStep
  9. | 
  10. |
  11. |   Copyright (c) 1992, 1993 Microsoft Corporation.  All Rights Reserved.
  12. |
  13. |    You have a royalty-free right to use, modify, reproduce and 
  14. |    distribute the Sample Files (and/or any modified version) in 
  15. |    any way you find useful, provided that you agree that 
  16. |    Microsoft has no warranty obligations or liability for any 
  17. |    Sample Application Files.
  18. |
  19. +--------------------------------------------------------------------*/
  20. #include <windows.h>
  21. #include <commdlg.h>
  22. #include <string.h>
  23. #include <stdlib.h>
  24. #include <stdio.h>
  25. #include <direct.h>
  26. #include <mmsystem.h>        
  27. #include <digitalv.h>        
  28. #include "movplay.h"
  29.  
  30.  
  31. /* function declarations */
  32. long FAR PASCAL _export WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
  33. void fileCloseMovie(HWND hWnd);
  34. void fileOpenMovie(HWND hWnd);
  35. void positionMovie(HWND hWnd);
  36. void playMovie(HWND hWnd, WORD wDirection);
  37. void seekMovie(HWND hWnd, WORD wAction);
  38. void stepMovie(HWND hWnd, WORD wDirection);
  39. void menubarUpdate(HWND hWnd);
  40. void titlebarUpdate(HWND hWnd, LPSTR lpstrMovie);
  41.  
  42.  
  43. /**************************************************************
  44. ************************ GLOBALS ******************************
  45. **************************************************************/
  46. /* AVI stuff to keep around */
  47. WORD wMCIDeviceID = 0;    /* MCI Device ID for the AVI file */
  48. HWND hwndMovie;        /* window handle of the movie */
  49. RECT rcMovie;        /* the rect where the movie is positioned      */
  50.             /* for QT/W this is the movie rect, for AVI    */
  51.             /* this is the location of the playback window */
  52. BOOL fPlaying = FALSE;    /* Play flag: TRUE == playing, FALSE == paused */
  53. BOOL fMovieOpen = FALSE;/* Open flag: TRUE == movie open, FALSE = none */
  54. HANDLE hAccel = NULL;    /* accelerator table */
  55. HMENU hMenuBar = NULL;    /* menu bar handle */
  56. char szAppName [] = "MovPlay";
  57.  
  58. /********************************************************************
  59. ************************** FUNCTIONS ********************************
  60. ********************************************************************/
  61. /*--------------------------------------------------------------+
  62. | initAVI - initialize avi libraries                |
  63. |                                |
  64. +--------------------------------------------------------------*/
  65. BOOL initAVI(void)
  66. {
  67.     return mciSendString("open avivideo", NULL, 0, NULL) == 0;
  68. }
  69.  
  70. void termAVI(void)
  71. {
  72.     mciSendString("close avivideo", NULL, 0, NULL);
  73. }
  74.  
  75. /*--------------------------------------------------------------+
  76. | initApp - initialize the app overall.                |
  77. |                                |
  78. | Returns the Window handle for the app on success, NULL if    |
  79. | there is a failure.                        |
  80. |                                |
  81. +--------------------------------------------------------------*/
  82. HWND initApp(HINSTANCE hInstance, HINSTANCE hPrevInstance, int nCmdShow)
  83. {
  84.    HWND        hWnd;    /* window handle to return */
  85.    
  86.    if (!hPrevInstance){
  87.       WNDCLASS    wndclass; 
  88.       
  89.       wndclass.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
  90.       wndclass.lpfnWndProc   = WndProc;
  91.       wndclass.cbClsExtra    = 0;
  92.       wndclass.cbWndExtra    = 0;
  93.       wndclass.hInstance     = hInstance;
  94.       wndclass.hIcon         = LoadIcon (hInstance, "AppIcon");
  95.       wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
  96.       wndclass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);
  97.       wndclass.lpszMenuName  = szAppName;
  98.       wndclass.lpszClassName = szAppName;
  99.  
  100.       if (!RegisterClass(&wndclass)){
  101.          MessageBox(NULL, "RegisterClass failure", szAppName, MB_OK);
  102.          return NULL;
  103.       }
  104.    }
  105.  
  106.    /* create the main window for the app */
  107.    hWnd = CreateWindow(szAppName, szAppName, WS_OVERLAPPEDWINDOW |
  108.       WS_CLIPCHILDREN, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  109.       CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
  110.  
  111.    if (hWnd == NULL){
  112.       MessageBox(NULL, "CreateWindow failure", szAppName, MB_OK);
  113.       return NULL;
  114.    }
  115.  
  116.    hMenuBar = GetMenu(hWnd);    /* get the menu bar handle */
  117.    menubarUpdate(hWnd);        /* update menu bar to disable Movie menu */
  118.    
  119.    /* Show the main window */
  120.    ShowWindow(hWnd, nCmdShow);
  121.    UpdateWindow(hWnd);
  122.  
  123.    /* load the accelerator table */
  124.    hAccel = LoadAccelerators(hInstance, szAppName);
  125.    
  126.    return hWnd;
  127. }
  128.  
  129.  
  130. /*--------------------------------------------------------------+
  131. | WinMain - main routine.                    |
  132. |                                |
  133. +--------------------------------------------------------------*/
  134. int PASCAL WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
  135.                 LPSTR lpszCmdParam, int nCmdShow)
  136. {
  137.    HWND        hWnd;
  138.    MSG         msg;
  139.  
  140.    if (!initAVI())
  141.        return 0;
  142.        
  143.    if ((hWnd = initApp(hInstance, hPrevInstance,nCmdShow)) == NULL)
  144.        return 0;    /* died initializing, bail out */
  145.  
  146.    /* main message loop, be sure to handle accelerators */
  147.    while (GetMessage(&msg, NULL, 0, 0)){
  148.       if (!TranslateAccelerator(hWnd, hAccel, &msg)) {
  149.           TranslateMessage(&msg);
  150.           DispatchMessage(&msg);
  151.       }
  152.    }
  153.  
  154.    return msg.wParam;
  155. }
  156.  
  157.  
  158. /*--------------------------------------------------------------+
  159. | WndProc - window proc for the app                |
  160. |                                |
  161. +--------------------------------------------------------------*/
  162. long FAR PASCAL _export WndProc (HWND hWnd, UINT message, WPARAM wParam,
  163.                         LPARAM lParam)
  164. {
  165.    PAINTSTRUCT ps;
  166.    WORD w;
  167.    WORD    wMenu;
  168.  
  169.    switch (message){
  170.         case WM_CREATE:
  171.         return 0;
  172.  
  173.     case WM_INITMENUPOPUP:
  174.         /* be sure this isn't the system menu */
  175.         if (HIWORD(lParam))
  176.             return DefWindowProc(hWnd, WM_INITMENUPOPUP, 
  177.                         wParam, lParam);
  178.   
  179.         wMenu = LOWORD(lParam);
  180.         switch (wMenu){
  181.             case 0:   /* file menu */
  182.                 /* turn on/off CLOSE & PLAY */
  183.                 if (fMovieOpen) w = MF_ENABLED|MF_BYCOMMAND;
  184.                 else        w = MF_GRAYED|MF_BYCOMMAND;
  185.                 EnableMenuItem((HMENU)wParam, IDM_CLOSE, w);
  186.                 break;
  187.                 
  188.             case 1:    /* Movie menu */
  189.                 /* check or uncheck the PLAY menu item */
  190.                 if (fPlaying)  w = MF_CHECKED|MF_BYCOMMAND;
  191.                 else           w = MF_UNCHECKED|MF_BYCOMMAND;
  192.                 CheckMenuItem((HMENU)wParam, IDM_PLAY, w);
  193.                 break;
  194.         } /* switch */
  195.         break;
  196.         
  197.     case WM_COMMAND:
  198.         /* handle the menu commands */
  199.         switch (wParam) {
  200.             /* File Menu */
  201.             case IDM_OPEN:
  202.                 fileOpenMovie(hWnd);
  203.                 break;
  204.             case IDM_CLOSE:
  205.                 fileCloseMovie(hWnd);
  206.                 break;
  207.             case IDM_EXIT:
  208.                 PostMessage(hWnd, WM_CLOSE, 0, 0L);
  209.                 break;
  210.             case IDM_ANOTHER:
  211.                 /* just fork another MovPlay */
  212.                 WinExec((LPSTR)szAppName, SW_SHOW);
  213.                 break;
  214.                 
  215.             /* Movie Menu - note some of these are by */
  216.             /* keyboard only, especially the REVERSE  */
  217.             /* commands.                  */
  218.             case IDM_PLAY:
  219.             case IDM_RPLAY:
  220.                 playMovie(hWnd, wParam);
  221.                 break;
  222.             case IDM_HOME:
  223.             case IDM_END:
  224.                 seekMovie(hWnd, wParam);
  225.                 break;
  226.             case IDM_STEP:
  227.             case IDM_RSTEP:
  228.                 stepMovie(hWnd,wParam);
  229.                 break;
  230.         }
  231.         return 0;
  232.  
  233.     case WM_SIZE:
  234.         positionMovie(hWnd);    /* re-center the movie */
  235.         return 0;
  236.         
  237.         case WM_PAINT:
  238.         if (!BeginPaint(hWnd, &ps))
  239.             return 0;
  240.         EndPaint(hWnd, &ps);
  241.         return 0;
  242.  
  243.     case WM_DESTROY:
  244.         if (fMovieOpen)
  245.             fileCloseMovie(hWnd);
  246.         termAVI();
  247.         PostQuitMessage(0);
  248.         return 0;
  249.         
  250.     case MM_MCINOTIFY:
  251.         /* This is where we check the status of an AVI    */
  252.         /* movie that might have been playing.  We do    */
  253.         /* the play with MCI_NOTIFY on so we should get    */
  254.         /* a MCI_NOTIFY_SUCCESSFUL if the play        */
  255.         /* completes on it's own.            */
  256.         switch(wParam){
  257.             case MCI_NOTIFY_SUCCESSFUL:
  258.                 /* the play finished, let's rewind */
  259.                 /* and clear our flag.           */
  260.                 fPlaying = FALSE;
  261.                 mciSendString("seek mov to start", NULL, 0,
  262.                         NULL);
  263.                 return 0;
  264.         }
  265.      
  266.    } /* switch */
  267.    return DefWindowProc(hWnd, message, wParam, lParam);
  268. }
  269.  
  270. /*--------------------------------------------------------------+
  271. | menubarUpdate - update the menu bar based on the <fMovieOpen> |
  272. |          flag value.  This will turn on/off the    |
  273. |          Movie menu.                    |
  274. |                                |
  275. +--------------------------------------------------------------*/
  276. void menubarUpdate(HWND hWnd)
  277. {
  278.    WORD w;
  279.    
  280.    if (fMovieOpen){
  281.        w = MF_ENABLED|MF_BYPOSITION;
  282.    } else {
  283.        w = MF_GRAYED|MF_BYPOSITION;
  284.    }
  285.    EnableMenuItem(hMenuBar, 1, w);    /* change the Movie menu (#1) */
  286.    DrawMenuBar(hWnd);    /* re-draw the menu bar */
  287. }
  288.  
  289. /*--------------------------------------------------------------+
  290. | titlebarUpdate - update the title bar to include the name    |
  291. |           of the movie playing.            |
  292. |                                |
  293. +--------------------------------------------------------------*/
  294. void titlebarUpdate(HWND hWnd, LPSTR lpstrMovie)
  295. {
  296.    char achNewTitle[BUFFER_LENGTH];    // space for the title 
  297.    
  298.    if (lpstrMovie != NULL)
  299.        wsprintf((LPSTR)achNewTitle,"%s - %s", (LPSTR)szAppName,lpstrMovie);
  300.    else
  301.        lstrcpy((LPSTR)achNewTitle, (LPSTR)szAppName);
  302.    SetWindowText(hWnd, (LPSTR)achNewTitle);
  303. }
  304.  
  305. /*--------------------------------------------------------------+ 
  306. | positionMovie - sets the movie rectange <rcMovie> to be    |
  307. |        centered within the app's window.        |
  308. |                                |
  309. +--------------------------------------------------------------*/
  310. VOID positionMovie(HWND hWnd)
  311. {
  312.    RECT    rcClient;
  313.    RECT rcMovieBounds;
  314.    char    achRect[128];
  315.    char *p;
  316.    
  317.    /* if there is no movie yet then just get out of here */
  318.    if (!fMovieOpen)
  319.        return;
  320.    
  321.    GetClientRect(hWnd, &rcClient);    /* get the parent windows rect */
  322.        
  323.    /* get the original size of the movie */
  324.    mciSendString("where mov source", (LPSTR)achRect, sizeof(achRect), NULL);
  325.    
  326.    SetRectEmpty(&rcMovieBounds);    // zero out movie rect
  327.    p = achRect;    // point to rectangle string returned by where command 
  328.    while (*p == ' ') p++;    // skip over starting spaces
  329.    while (*p != ' ') p++;    // skip over the x (which is 0) 
  330.    while (*p == ' ') p++;    // skip over spaces between x and y
  331.    while (*p != ' ') p++;    // skip over the y (which is 0)
  332.    while (*p == ' ') p++;    // skip over the spaces between y and width
  333.        
  334.    /* now find the width */
  335.    for (; *p >= '0' && *p <= '9'; p++)
  336.        rcMovieBounds.right = (10 * rcMovieBounds.right) + (*p - '0');
  337.    while (*p == ' ') p++;    // skip spaces between width and height
  338.    
  339.    /* now find the height */
  340.    for (; *p >= '0' && *p <= '9'; p++)
  341.        rcMovieBounds.bottom = (10 * rcMovieBounds.bottom) + (*p - '0');
  342.  
  343.    /* figure out where to position the window at */
  344.    rcMovie.left = (rcClient.right/2) - (rcMovieBounds.right / 2);
  345.    rcMovie.top = (rcClient.bottom/2) - (rcMovieBounds.bottom / 2);
  346.    rcMovie.right = rcMovie.left + rcMovieBounds.right;
  347.    rcMovie.bottom = rcMovie.top + rcMovieBounds.bottom;
  348.    
  349.    /* reposition the playback (child) window */
  350.    MoveWindow(hwndMovie, rcMovie.left, rcMovie.top,
  351.        rcMovieBounds.right, rcMovieBounds.bottom, TRUE);
  352. }
  353.  
  354. /*--------------------------------------------------------------+ 
  355. | fileCloseMovie - close the movie and anything associated    |
  356. |           with it.                    |
  357. |                                |
  358. | This function clears the <fPlaying> and <fMovieOpen> flags    |
  359. |                                |
  360. +--------------------------------------------------------------*/
  361. void fileCloseMovie(HWND hWnd)
  362. {
  363.   mciSendString("close mov", NULL, 0, NULL);
  364.  
  365.   fPlaying = FALSE;    // can't be playing any longer
  366.   fMovieOpen = FALSE;    // no more movies open
  367.        
  368.   titlebarUpdate(hWnd, NULL);    // title bar back to plain
  369.   menubarUpdate(hWnd);        // update menu bar
  370.        
  371.   /* cause a total repaint to occur */
  372.   InvalidateRect(hWnd, NULL, TRUE);
  373.   UpdateWindow(hWnd);
  374. }
  375.  
  376.  
  377. /*--------------------------------------------------------------+ 
  378. | fileOpenMovie - open an AVI movie. Use CommDlg open box to    |
  379. |            open and then handle the initialization to    |
  380. |        show the movie and position it properly.  Keep    |
  381. |        the movie paused when opened.            |
  382. |                                |
  383. |        Sets <fMovieOpened> on success.            |
  384. +--------------------------------------------------------------*/
  385. void fileOpenMovie(HWND hWnd)
  386. {
  387.    OPENFILENAME ofn;
  388.    
  389.    static char szFile [BUFFER_LENGTH];
  390.    static char szFileTitle [BUFFER_LENGTH];
  391.    static int  nLastFilter = 1;      /* keep last file-type opened */
  392.  
  393.    /* use the OpenFile dialog to get the filename */
  394.    memset(&ofn, 0, sizeof(ofn));
  395.    ofn.lStructSize = sizeof(ofn);
  396.    ofn.hwndOwner = hWnd;
  397.    ofn.lpstrFilter = "Video for Windows\0*.avi\0\0";
  398.    ofn.nFilterIndex = nLastFilter;
  399.    ofn.lpstrFile = szFile;
  400.    ofn.nMaxFile = sizeof(szFile);
  401.    ofn.lpstrFileTitle = szFileTitle;
  402.    ofn.nMaxFileTitle = sizeof(szFileTitle);
  403.    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
  404.  
  405.    /* use CommDlg to get our filename */
  406.    if (GetOpenFileName(&ofn)){
  407.      char    achCommand[BUFFER_LENGTH];
  408.      DWORD  dw;
  409.  
  410.      /* we got a filename, now close any old movie and open */
  411.      /* the new one.                    */
  412.      if (fMovieOpen)
  413.          fileCloseMovie(hWnd);    
  414.      
  415.      /* we have a .AVI movie to open, use MCI */
  416.      /* 
  417.      | build up the string -
  418.      |      open alias mov parent HWND FILENAME
  419.      | to pass to mciSendString 
  420.      */
  421.     wsprintf((LPSTR)achCommand,"open %s alias mov style child parent %d",
  422.              ofn.lpstrFile,hWnd);
  423.  
  424.      /* try to open the file */
  425.      if (mciSendString((LPSTR)achCommand, NULL, 0, NULL) == 0){
  426.  
  427.          fMovieOpen = TRUE;
  428.  
  429.          /* we opened the file o.k., now set up to */
  430.          /* play it.                   */
  431.          mciSendString("window mov state show", NULL, 0, NULL);
  432.          /* get the window handle */
  433.          if ((dw = mciSendString("status mov window handle", 
  434.             (LPSTR)achCommand, sizeof(achCommand), 
  435.             NULL)) == 0L)
  436.             hwndMovie = (HWND)atoi(achCommand);
  437.          else {
  438.              mciGetErrorString(dw, achCommand, 
  439.                      sizeof(achCommand));
  440.              MessageBox(hWnd, achCommand, NULL,
  441.                  MB_ICONEXCLAMATION|MB_OK);
  442.          }
  443.          /* now get the movie centered */
  444.          positionMovie(hWnd);
  445.      } else {
  446.          /* generic error for open */
  447.          MessageBox(hWnd, "Unable to open Movie", NULL, 
  448.                   MB_ICONEXCLAMATION|MB_OK);
  449.          fMovieOpen = FALSE;
  450.      }
  451.    }
  452.    /* update menu and title bars */
  453.    if (fMovieOpen)
  454.        titlebarUpdate(hWnd, (LPSTR)ofn.lpstrFileTitle);
  455.    else
  456.        titlebarUpdate(hWnd, NULL);
  457.    menubarUpdate(hWnd);
  458.    
  459.    
  460.    /* cause an update to occur */
  461.    InvalidateRect(hWnd, NULL, FALSE);
  462.    UpdateWindow(hWnd);
  463. }
  464.  
  465. /*--------------------------------------------------------------+
  466. | playMovie - play/pause the movie depending on the state    |
  467. |        of the <fPlaying> flag.                |
  468. |                                |
  469. | This function sets the <fPlaying> flag appropriately when done|
  470. |                                |
  471. +--------------------------------------------------------------*/
  472. void playMovie(HWND hWnd, WORD wDirection)
  473. {
  474.    fPlaying = !fPlaying;    /* swap the play flag */
  475.    if (wDirection == NULL)
  476.        fPlaying = FALSE;    /* wDirection == NULL means PAUSE */
  477.  
  478.    /* play/pause the AVI movie */
  479.    if (fPlaying){
  480.        if (wDirection == IDM_RPLAY){
  481.             mciSendString("play mov reverse notify", NULL, 0, hWnd);
  482.        } else {
  483.            mciSendString("play mov notify", NULL, 0, hWnd);
  484.        }
  485.    } else {
  486.        /* tell it to pause */
  487.        mciSendString("pause mov", NULL, 0, NULL);
  488.    }
  489. }
  490.  
  491. /*--------------------------------------------------------------+
  492. | seekMovie - seek in the movie depending on the wAction.    |
  493. |          Possible actions are IDM_HOME (start of movie) or    |
  494. |          IDM_END (end of movie)                |
  495. |                                |
  496. |          Always stop the play before seeking.        |
  497. |                                |
  498. +--------------------------------------------------------------*/
  499. void seekMovie(HWND hWnd, WORD wAction)
  500. {
  501.    /* first stop the movie from playing if it is playing */
  502.    if (fPlaying){
  503.        playMovie(hWnd, NULL);    
  504.    }
  505.    if (wAction == IDM_HOME){
  506.        /* home the movie */
  507.            mciSendString("seek mov to start", NULL, 0, NULL);
  508.             
  509.    } else if (wAction == IDM_END){
  510.        /* go to the end of the movie */
  511.            mciSendString("seek mov to end", NULL, 0, NULL);
  512.    } 
  513. }
  514.  
  515. /*--------------------------------------------------------------+
  516. | stepMovie - step forward or reverse in the movie.  wDirection    |
  517. |        can be IDM_STEP (forward) or IDM_RSTEP (reverse)|
  518. |                                |
  519. |        Again, stop the play if one is in progress.    |
  520. |                                |
  521. +--------------------------------------------------------------*/
  522. void stepMovie(HWND hWnd, WORD wDirection)
  523. {
  524.    if (fPlaying)
  525.        playMovie(hWnd, NULL);  /* turn off the movie */
  526.        
  527.    if (wDirection == IDM_STEP)
  528.        mciSendString("step mov by 1", NULL, 0, NULL);
  529.    else
  530.        mciSendString("step mov reverse by 1", NULL,0, NULL);
  531. }
  532.  
  533. /*--------------------------- end of file ----------------------*/
  534.